package domain

import (
	"album/dao"
	"album/model"
	"album/repo"
	"context"
	"errors"
	"github.com/jinzhu/copier"
	"github.com/zeromicro/go-zero/core/logx"
	"grpc-common/album/types/album"
	"listenboos-common/db"
)

type AlbumInfoDomain struct {
	albumRepo          repo.AlbumInfoRepo
	category1Repo      repo.BaseCategory1Repo
	category2Repo      repo.BaseCategory2Repo
	category3Repo      repo.BaseCategory3Repo
	attributeRepo      repo.BaseAttributeRepo
	attributeValueRepo repo.BaseAttributeValueRepo
}

func (u *AlbumInfoDomain) GetByC1IdToAttribute(ctx context.Context, cid int64) (att []*model.BaseAttribute, err error) {
	att, err = u.attributeRepo.FindByC1IdToAttribute(ctx, cid)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return att, err
}
func (u *AlbumInfoDomain) GetByC1IdToAttributeValue(ctx context.Context, aid int64) (att []*model.BaseAttributeValue, err error) {
	att, err = u.attributeValueRepo.FindByAidToValue(ctx, aid)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return att, err
}
func (u *AlbumInfoDomain) GetAllCategoryList(ctx context.Context) (albums []*model.AlbumInfo, err error) {
	albums, err = u.albumRepo.GetAllCategoryList(ctx)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return albums, err
}
func (u *AlbumInfoDomain) FindByCategory1ById(ctx context.Context, category1Id int64) (category1 *model.BaseCategory1, err error) {
	category1, err = u.category1Repo.FindByCategory1ById(ctx, category1Id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return category1, err
}
func (u *AlbumInfoDomain) FindByCategory1(ctx context.Context, category1Id int64) (category1 []*model.BaseCategory1, err error) {
	category1, err = u.category1Repo.FindByCategory1(ctx, category1Id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return category1, err
}
func (u *AlbumInfoDomain) FindByCategory2(ctx context.Context, category1Id int64) (category2 []*model.BaseCategory2, err error) {
	category2, err = u.category2Repo.FindByCategory2(ctx, category1Id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return category2, err
}
func (u *AlbumInfoDomain) FindByCategory2ToC1d(ctx context.Context, category2Id int64) (c1id int64, err error) {
	c1id, err = u.category3Repo.FindByCategory2ToC1Id(ctx, category2Id)
	if err != nil {
		logx.Error(err)
		return 0, errors.New("数据库异常")
	}
	return c1id, err
}

// 潮汛分类id
func (u *AlbumInfoDomain) FindByCategory3ToC2Id(ctx context.Context, category3Id int64) (c2id int64, err error) {
	c2id, err = u.category3Repo.FindByCategory3ToC2Id(ctx, category3Id)
	if err != nil {
		logx.Error(err)
		return 0, errors.New("数据库异常")
	}
	return c2id, err
}
func (u *AlbumInfoDomain) FindCategory3ById(ctx context.Context, id int64) (category3 *model.BaseCategory3, err error) {
	category3, err = u.category3Repo.FindCategory3ById(ctx, id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return category3, err
}
func (u *AlbumInfoDomain) FindCategory2ById(ctx context.Context, c3id int64) (category2 *model.BaseCategory2, err error) {
	category2, err = u.category2Repo.FindCategory2ById(ctx, c3id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return category2, err
}
func (u *AlbumInfoDomain) FindCategory1ById(ctx context.Context, c2id int64) (category1 *model.BaseCategory1, err error) {
	category1, err = u.category1Repo.FindCategory1ById(ctx, c2id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return category1, err
}
func (u *AlbumInfoDomain) FindByCategory3(ctx context.Context, category2Id int64) (category3 []*model.BaseCategory3, err error) {
	category3, err = u.category3Repo.FindByCategory3(ctx, category2Id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return category3, err
}

// todo:
func (u *AlbumInfoDomain) FindByCategory3To8(ctx context.Context, category2Id int64) (category3 []*model.BaseCategory3, err error) {
	category3, err = u.category3Repo.FindByCategory3To8(ctx, category2Id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return category3, err
}
func (u *AlbumInfoDomain) SaveAlbumInfo(ctx context.Context, conn db.DBConn, in *album.SaveAlbumInfoReq) (id int64, err error) {
	var data model.AlbumInfo
	err = copier.Copy(&data, &in)
	data.IsOpen = in.IsOpen
	if err != nil {
		return 0, err
	}
	if in.AlbumId != 0 {
		data.Id = in.AlbumId
	}
	// 判断是否付费
	if data.PayType == "0103" {
		data.TracksForFree = 5
		data.SecondsForFree = 30
	}
	id, err = u.albumRepo.Save(ctx, conn, &data)
	if err != nil {
		logx.Error(err)
		return 0, errors.New("数据库异常")
	}
	return id, nil
}
func (u *AlbumInfoDomain) FindAlbumByIdAndUserId(ctx context.Context, albumId int64, userId int64) (att *model.AlbumInfo, err error) {
	att, err = u.albumRepo.FindAlbumByIdAndUserId(ctx, albumId, userId)
	if err != nil {
		logx.Error(err)
		return nil, err
	}
	return att, err
}
func (u *AlbumInfoDomain) FindAlbumById(ctx context.Context, albumId int64) (att *model.AlbumInfo, err error) {
	att, err = u.albumRepo.FindAlbumById(ctx, albumId)
	if err != nil {
		logx.Error(err)
		return nil, nil
	}
	return att, nil
}

func (u *AlbumInfoDomain) FindAlbumByUserId(ctx context.Context, in *album.FindUserAlbumReq) (albums []*model.AlbumInfo, err error) {
	albums, err = u.albumRepo.FindByUserId(ctx, in.UserId, in.PageNum, in.PageSize)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return albums, nil
}

func (u *AlbumInfoDomain) DeleteAlbumInfo(ctx context.Context, conn db.DBConn, in *album.RemoteReq) error {
	err := u.albumRepo.DeleteAlbumInfo(ctx, conn, in.AlbumId, in.UserId)
	if err != nil {
		logx.Error(err)
		return errors.New("数据库异常")
	}
	return nil
}

func (u *AlbumInfoDomain) FindAlbumListByUserId(ctx context.Context, userId int64) (albums []*model.AlbumInfo, err error) {
	albums, err = u.albumRepo.FindAlbumListByUserId(ctx, userId)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return albums, nil
}

func (u *AlbumInfoDomain) FindByCategory1ToC2Id(ctx context.Context, category1Id int64) (c2 []*model.BaseCategory2, err error) {
	c2, err = u.category2Repo.FindByCategory2(ctx, category1Id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return c2, err
}

func (u *AlbumInfoDomain) InitBloom() {
	// 把专辑id插入到bloom里
	u.albumRepo.InitBloom()
}

func (u *AlbumInfoDomain) FindByCategory2ByOrder(ctx context.Context, category1Id int64) (c2 []*model.BaseCategory2, err error) {
	c2, err = u.category2Repo.FindByCategory2ByOrder(ctx, category1Id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return c2, err
}

func (u *AlbumInfoDomain) FindByCategory3To8Desc(ctx context.Context, category2Id int64) (category3 []*model.BaseCategory3, err error) {
	category3, err = u.category3Repo.FindByCategory3To8Desc(ctx, category2Id)
	if err != nil {
		logx.Error(err)
		return nil, errors.New("数据库异常")
	}
	return category3, err
}

//	func (u *AlbumInfoDomain) FindAlbumInfoById(ctx context.Context, id int64) (albumInfo *model.AlbumInfo, err error) {
//		albumInfo, err = u.albumRepo.FindAlbumInfoById(ctx, id)
//		if err != nil {
//			logx.Error(err)
//			return nil, errors.New("数据库异常")
//		}
//		return albumInfo, err
//	}
func NewAlbumInfoDomain(db *db.ListenDB) *AlbumInfoDomain {
	return &AlbumInfoDomain{
		albumRepo:          dao.NewAlbumInfoDao(db),
		category1Repo:      dao.NewBaseCategory1Dao(db),
		category2Repo:      dao.NewBaseCategory2Dao(db),
		category3Repo:      dao.NewBaseCategory3Dao(db),
		attributeRepo:      dao.NewBaseAttributeDao(db),
		attributeValueRepo: dao.NewBaseAttributeValueDao(db),
	}
}
